Define and reference a variable:
No type declaration needed!
(But values still have types--let's check.)
Everything in python is an object. Python variables are like pointers.
(if that word makes sense)
a = [1,2,3]
b = a
You can see this pointer with id().
The is operator tests for object sameness.
This is a stronger condition than being equal!
a = [1,2,3]
b = [1,2,3]
print("IS ", a is b)
print("EQUAL", a == b)
What do you think the following prints?
a = [1,2,3]
b = a
a = a + [4]
print(b)
print(a)
a is b
Why is that?
How could this lead to bugs?
To help manage this risk, Python provides immutable types.
Immutable types cannot be changed in-place, only by creating a new object.
A tuple is an immutable list.
a = [1,2,3]
type(a)
a[2] = 0
print(a)
Let's try to change that tuple.
# clear
a[2] = 0
Bonus question: How do you spell a single-element tuple?
String is also immutable type.
myName = 'Mariena'
Note that myName is spelled incorrectly. We would like to change the letter "e" with a letter "a"
myName[4]
myName[4]='a'
a = "apple"
b = "apple"
print(id(a),id(b))
print (a is b)
print (a == b)
<img src="PointToString.png",width=200>
Note that "a" and "b" are bounded to the same object "apple", and therefore they have the same id. For optimization reasons, Python does not store duplicates of "simple" strings. But if the strings are a little more complicated...
a = "Hello, how are you?"
b = "Hello, how are you?"
print(id(a),id(b))
print (a is b)
print (a == b)
This is called interning, and Python does interning (to some extent) of shorter string literals (such as "apple") which are created at compile time. But in general, Python string literals creates a new string object each time (as in "Hello, how are you?"). Interning is runtime dependant and is always a trade-off between memory use and the cost of checking if you are creating the same string.
In general, integers, floats, lists, tuples, etc, will be stored at different locations, and therefore have different ids.
a = 5000
b = 5000
print(id(a),id(b))
print (a is b)
print (a == b)
a = (1,[2,3],4)
b = (1,[2,3],4)
print(id(a),id(b))
print (a is b)
print (a == b)
Also for optimization reasons, Python will not duplicate integers between -5 and 256. Instead, it will keep an array of integer objects for all integers between -5 and 256, so when you create an int in that range you actually just get back a reference to the existing object.
a = 256
b = 256
print(id(a),id(b))
print (a is b)
print (a == b)
a = 257
b = 257
print(id(a),id(b))
print (a is b)
print (a == b)